home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / m2c / EvalC.c < prev    next >
C/C++ Source or Header  |  1992-11-24  |  40KB  |  1,153 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_StringMem
  20. #include "StringMem.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Idents
  24. #include "Idents.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Texts
  28. #include "Texts.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Sets
  32. #include "Sets.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_TreeC1
  36. #include "TreeC1.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_TreeC2
  40. #include "TreeC2.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_EvalC3
  44. #include "EvalC3.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Tree
  48. #include "Tree.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_EvalC
  52. #include "EvalC.h"
  53. #endif
  54.  
  55. Tree_tTree EvalC_Class;
  56. IO_tFile EvalC_yyf;
  57. PROC EvalC_Exit;
  58.  
  59. static SHORTCARD n;
  60. static Tree_tTree Node, Attr, ChildsClass;
  61. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  62. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  63. struct S_3 {
  64.     union {
  65.         char dummy;
  66.     } U_1;
  67. };
  68. struct S_4 {
  69.     union {
  70.         char dummy;
  71.     } U_1;
  72. };
  73. struct S_5 {
  74.     union {
  75.         char dummy;
  76.     } U_1;
  77. };
  78. static void TypeName ARGS((Tree_tTree t));
  79. struct S_6 {
  80.     union {
  81.         char dummy;
  82.     } U_1;
  83. };
  84. struct S_7 {
  85.     union {
  86.         struct {
  87.             struct S_8 {
  88.                 Tree_tTree TheClass;
  89.                 INTEGER k;
  90.             } yyR8;
  91.         } V_1;
  92.     } U_1;
  93. };
  94. static void yyExit ARGS(());
  95.  
  96.  
  97. static void yyAbort
  98. # ifdef __STDC__
  99. (CHAR yyFunction[], LONGCARD O_1)
  100. # else
  101. (yyFunction, O_1)
  102. CHAR yyFunction[];
  103. LONGCARD O_1;
  104. # endif
  105. {
  106.   OPEN_ARRAY_LOCALS
  107.  
  108.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  109.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  110.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module EvalC, routine ", 29L);
  111.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  112.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  113.   IO_WriteNl((System_tFile)IO_StdError);
  114.   (*EvalC_Exit)();
  115.   FREE_OPEN_ARRAYS
  116. }
  117.  
  118. static BOOLEAN yyIsEqual
  119. # ifdef __STDC__
  120. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  121. # else
  122. (yya, O_3, yyb, O_2)
  123. BYTE yya[];
  124. LONGCARD O_3;
  125. BYTE yyb[];
  126. LONGCARD O_2;
  127. # endif
  128. {
  129.   INTEGER yyi;
  130.   OPEN_ARRAY_LOCALS
  131.  
  132.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  133.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  134.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  135.   {
  136.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  137.  
  138.     if (B_1 <= B_2)
  139.       for (yyi = B_1;; yyi += 1) {
  140.         if (yya[yyi] != yyb[yyi]) {
  141.           FREE_OPEN_ARRAYS
  142.           return FALSE;
  143.         }
  144.         if (yyi >= B_2) break;
  145.       }
  146.   }
  147.   FREE_OPEN_ARRAYS
  148.   return TRUE;
  149. }
  150.  
  151. void EvalC_EvalDefC
  152. # ifdef __STDC__
  153. (Tree_tTree t)
  154. # else
  155. (t)
  156. Tree_tTree t;
  157. # endif
  158. {
  159.   struct S_3 yyTempo;
  160.  
  161.   if (t == Tree_NoTree) {
  162.     return;
  163.   }
  164.   if (t->U_1.V_1.Kind == Tree_Ag) {
  165.     {
  166.       register Tree_yAg *W_1 = &t->U_1.V_26.Ag;
  167.  
  168.       IO_WriteS(Tree_f, (STRING)"# ifndef yy", 11L);
  169.       Tree_WI(W_1->EvalName);
  170.       IO_WriteNl(Tree_f);
  171.       IO_WriteS(Tree_f, (STRING)"# define yy", 11L);
  172.       Tree_WI(W_1->EvalName);
  173.       IO_WriteNl(Tree_f);
  174.       IO_WriteNl(Tree_f);
  175.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  176.       IO_WriteNl(Tree_f);
  177.       IO_WriteS(Tree_f, (STRING)"# define ARGS(parameters)    parameters", 36L);
  178.       IO_WriteNl(Tree_f);
  179.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  180.       IO_WriteNl(Tree_f);
  181.       IO_WriteS(Tree_f, (STRING)"# define ARGS(parameters)    ()", 28L);
  182.       IO_WriteNl(Tree_f);
  183.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  184.       IO_WriteNl(Tree_f);
  185.       IO_WriteNl(Tree_f);
  186.       IO_WriteS(Tree_f, (STRING)"# include \"", 11L);
  187.       Tree_WI(Tree_iMain);
  188.       IO_WriteS(Tree_f, (STRING)".h\"", 3L);
  189.       IO_WriteNl(Tree_f);
  190.       IO_WriteNl(Tree_f);
  191.       TreeC2_WriteLine(W_1->EvalCodes->U_1.V_12.Codes.ImportLine);
  192.       Texts_WriteText(Tree_f, W_1->EvalCodes->U_1.V_12.Codes.Import);
  193.       Node = W_1->Modules;
  194.       while (Node->U_1.V_1.Kind == Tree_Module) {
  195.         TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.ImportLine);
  196.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Import);
  197.         Node = Node->U_1.V_43.Module.Next;
  198.       }
  199.       TreeC2_WriteLine(W_1->EvalCodes->U_1.V_12.Codes.ExportLine);
  200.       Texts_WriteText(Tree_f, W_1->EvalCodes->U_1.V_12.Codes.Export);
  201.       Node = W_1->Modules;
  202.       while (Node->U_1.V_1.Kind == Tree_Module) {
  203.         TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.ExportLine);
  204.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Export);
  205.         Node = Node->U_1.V_43.Module.Next;
  206.       }
  207.       IO_WriteNl(Tree_f);
  208.       IO_WriteS(Tree_f, (STRING)"extern void ", 12L);
  209.       Tree_WI(W_1->EvalName);
  210.       IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  211.       Tree_WI(Tree_itTree);
  212.       IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  213.       IO_WriteNl(Tree_f);
  214.       IO_WriteS(Tree_f, (STRING)"extern void Begin", 17L);
  215.       Tree_WI(W_1->EvalName);
  216.       IO_WriteS(Tree_f, (STRING)" ();", 4L);
  217.       IO_WriteNl(Tree_f);
  218.       IO_WriteS(Tree_f, (STRING)"extern void Close", 17L);
  219.       Tree_WI(W_1->EvalName);
  220.       IO_WriteS(Tree_f, (STRING)" ();", 4L);
  221.       IO_WriteNl(Tree_f);
  222.       IO_WriteNl(Tree_f);
  223.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  224.       IO_WriteNl(Tree_f);
  225.       return;
  226.     }
  227.   }
  228. }
  229.  
  230. void EvalC_EvalImplHead
  231. # ifdef __STDC__
  232. (Tree_tTree t)
  233. # else
  234. (t)
  235. Tree_tTree t;
  236. # endif
  237. {
  238.   struct S_4 yyTempo;
  239.  
  240.   if (t == Tree_NoTree) {
  241.     return;
  242.   }
  243.   if (t->U_1.V_1.Kind == Tree_Ag) {
  244.     {
  245.       register Tree_yAg *W_2 = &t->U_1.V_26.Ag;
  246.  
  247.       IO_WriteS(Tree_f, (STRING)"# define DEP(a, b) a", 20L);
  248.       IO_WriteNl(Tree_f);
  249.       IO_WriteS(Tree_f, (STRING)"# define SELF yyt", 17L);
  250.       IO_WriteNl(Tree_f);
  251.       IO_WriteS(Tree_f, (STRING)"# include \"", 11L);
  252.       Tree_WI(W_2->EvalName);
  253.       IO_WriteS(Tree_f, (STRING)".h\"", 3L);
  254.       IO_WriteNl(Tree_f);
  255.       if (Sets_IsElement(ORD('Y'), &Tree_Options) || Sets_IsElement(ORD('Z'), &Tree_Options) || Sets_IsElement(ORD('L'), &Tree_Options)) {
  256.         IO_WriteS(Tree_f, (STRING)"# include <stdio.h>", 19L);
  257.         IO_WriteNl(Tree_f);
  258.       }
  259.       if (Sets_IsElement(ORD('Y'), &Tree_Options) || Sets_IsElement(ORD('Z'), &Tree_Options)) {
  260.         IO_WriteS(Tree_f, (STRING)"# ifdef __cplusplus", 19L);
  261.         IO_WriteNl(Tree_f);
  262.         IO_WriteS(Tree_f, (STRING)"extern \"C\" {", 12L);
  263.         IO_WriteNl(Tree_f);
  264.         IO_WriteS(Tree_f, (STRING)"# include \"Idents.h\"", 20L);
  265.         IO_WriteNl(Tree_f);
  266.         IO_WriteS(Tree_f, (STRING)"# include \"Sets.h\"", 18L);
  267.         IO_WriteNl(Tree_f);
  268.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  269.         IO_WriteNl(Tree_f);
  270.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  271.         IO_WriteNl(Tree_f);
  272.         IO_WriteS(Tree_f, (STRING)"# include \"Idents.h\"", 20L);
  273.         IO_WriteNl(Tree_f);
  274.         IO_WriteS(Tree_f, (STRING)"# include \"Sets.h\"", 18L);
  275.         IO_WriteNl(Tree_f);
  276.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  277.         IO_WriteNl(Tree_f);
  278.       }
  279.       if (Sets_IsElement(ORD('9'), &Tree_Options)) {
  280.         IO_WriteS(Tree_f, (STRING)"# ifdef __cplusplus", 19L);
  281.         IO_WriteNl(Tree_f);
  282.         IO_WriteS(Tree_f, (STRING)"extern \"C\" {", 12L);
  283.         IO_WriteNl(Tree_f);
  284.         IO_WriteS(Tree_f, (STRING)"# include \"General.h\"", 21L);
  285.         IO_WriteNl(Tree_f);
  286.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  287.         IO_WriteNl(Tree_f);
  288.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  289.         IO_WriteNl(Tree_f);
  290.         IO_WriteS(Tree_f, (STRING)"# include \"General.h\"", 21L);
  291.         IO_WriteNl(Tree_f);
  292.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  293.         IO_WriteNl(Tree_f);
  294.         IO_WriteNl(Tree_f);
  295.         IO_WriteS(Tree_f, (STRING)"static int xxStack;", 19L);
  296.         IO_WriteNl(Tree_f);
  297.       }
  298.       TreeC2_WriteLine(W_2->EvalCodes->U_1.V_12.Codes.GlobalLine);
  299.       Texts_WriteText(Tree_f, W_2->EvalCodes->U_1.V_12.Codes.Global);
  300.       Node = W_2->Modules;
  301.       while (Node->U_1.V_1.Kind == Tree_Module) {
  302.         TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.GlobalLine);
  303.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Global);
  304.         Node = Node->U_1.V_43.Module.Next;
  305.       }
  306.       IO_WriteNl(Tree_f);
  307.       if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  308.         IO_WriteS(Tree_f, (STRING)"# include \"yy", 13L);
  309.         Tree_WI(Tree_iModule);
  310.         IO_WriteS(Tree_f, (STRING)".w\"", 3L);
  311.         IO_WriteNl(Tree_f);
  312.         IO_WriteS(Tree_f, (STRING)"# define yyWrite", 16L);
  313.         Tree_WI(Tree_iMain);
  314.         IO_WriteS(Tree_f, (STRING)"(a) Write", 9L);
  315.         Tree_WI(Tree_iMain);
  316.         IO_WriteS(Tree_f, (STRING)" (yyf, a)", 9L);
  317.         IO_WriteNl(Tree_f);
  318.       }
  319.       IO_WriteNl(Tree_f);
  320.       IO_WriteS(Tree_f, (STRING)"static char yyb;", 16L);
  321.       IO_WriteNl(Tree_f);
  322.       if (Sets_IsElement(ORD('Y'), &Tree_Options) || Sets_IsElement(ORD('Z'), &Tree_Options)) {
  323.         IO_WriteNl(Tree_f);
  324.         IO_WriteS(Tree_f, (STRING)"# define yyTrace    true", 21L);
  325.         IO_WriteNl(Tree_f);
  326.         IO_WriteNl(Tree_f);
  327.         IO_WriteS(Tree_f, (STRING)"static char * yyTypeName [", 26L);
  328.         Tree_WN(Tree_ClassCount);
  329.         IO_WriteS(Tree_f, (STRING)" + 1] = { 0,", 12L);
  330.         IO_WriteNl(Tree_f);
  331.         Tree_ForallClasses(W_2->Classes, (Tree_ProcOfT)TypeName);
  332.         IO_WriteS(Tree_f, (STRING)"};", 2L);
  333.         IO_WriteNl(Tree_f);
  334.         IO_WriteNl(Tree_f);
  335.         IO_WriteS(Tree_f, (STRING)"static void yyWriteType", 23L);
  336.         IO_WriteNl(Tree_f);
  337.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  338.         IO_WriteNl(Tree_f);
  339.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  340.         Tree_WI(Tree_itTree);
  341.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  342.         IO_WriteNl(Tree_f);
  343.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  344.         IO_WriteNl(Tree_f);
  345.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  346.         Tree_WI(Tree_itTree);
  347.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  348.         IO_WriteNl(Tree_f);
  349.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  350.         IO_WriteNl(Tree_f);
  351.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  352.         IO_WriteNl(Tree_f);
  353.         IO_WriteS(Tree_f, (STRING)" char * yys = yyTypeName [yyt->Kind];", 37L);
  354.         IO_WriteNl(Tree_f);
  355.         IO_WriteS(Tree_f, (STRING)" register int yyi = 16 - strlen (yys);", 38L);
  356.         IO_WriteNl(Tree_f);
  357.         IO_WriteS(Tree_f, (STRING)" (void) printf (\"%s\", yys);", 27L);
  358.         IO_WriteNl(Tree_f);
  359.         IO_WriteS(Tree_f, (STRING)" while (yyi -- > 0) (void) putc (' ', stdout);", 46L);
  360.         IO_WriteNl(Tree_f);
  361.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  362.         IO_WriteNl(Tree_f);
  363.       }
  364.       if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  365.         IO_WriteNl(Tree_f);
  366.         IO_WriteS(Tree_f, (STRING)"static FILE * yyf = stdout;", 27L);
  367.         IO_WriteNl(Tree_f);
  368.         IO_WriteNl(Tree_f);
  369.         IO_WriteS(Tree_f, (STRING)"static void yyWriteHex", 22L);
  370.         IO_WriteNl(Tree_f);
  371.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  372.         IO_WriteNl(Tree_f);
  373.         IO_WriteS(Tree_f, (STRING)" (unsigned char * yyx, int yysize)", 34L);
  374.         IO_WriteNl(Tree_f);
  375.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  376.         IO_WriteNl(Tree_f);
  377.         IO_WriteS(Tree_f, (STRING)" (yyx, yysize) unsigned char * yyx; int yysize;", 47L);
  378.         IO_WriteNl(Tree_f);
  379.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  380.         IO_WriteNl(Tree_f);
  381.         IO_WriteS(Tree_f, (STRING)"{ register int yyi; for (yyi = 0; yyi < yysize; yyi ++) (void) printf (\"%02x \", yyx [yyi]); }", 93L);
  382.         IO_WriteNl(Tree_f);
  383.         IO_WriteNl(Tree_f);
  384.         IO_WriteS(Tree_f, (STRING)"static void yyWriteNl () { if (yyTrace) { (void) putc ('\\n', stdout); (void) fflush (stdout); } }", 97L);
  385.         IO_WriteNl(Tree_f);
  386.       }
  387.       if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  388.         IO_WriteNl(Tree_f);
  389.         IO_WriteS(Tree_f, (STRING)"static void yyWriteEval", 23L);
  390.         IO_WriteNl(Tree_f);
  391.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  392.         IO_WriteNl(Tree_f);
  393.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  394.         Tree_WI(Tree_itTree);
  395.         IO_WriteS(Tree_f, (STRING)" yyt, char * yys)", 17L);
  396.         IO_WriteNl(Tree_f);
  397.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  398.         IO_WriteNl(Tree_f);
  399.         IO_WriteS(Tree_f, (STRING)" (yyt, yys) ", 12L);
  400.         Tree_WI(Tree_itTree);
  401.         IO_WriteS(Tree_f, (STRING)" yyt; char * yys;", 17L);
  402.         IO_WriteNl(Tree_f);
  403.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  404.         IO_WriteNl(Tree_f);
  405.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  406.         IO_WriteNl(Tree_f);
  407.         IO_WriteS(Tree_f, (STRING)" if (yyTrace) {", 15L);
  408.         IO_WriteNl(Tree_f);
  409.         IO_WriteS(Tree_f, (STRING)"  register int yyi = 24 - strlen (yys);", 39L);
  410.         IO_WriteNl(Tree_f);
  411.         IO_WriteS(Tree_f, (STRING)"  yyWriteType (yyt);", 20L);
  412.         IO_WriteNl(Tree_f);
  413.         IO_WriteS(Tree_f, (STRING)"  (void) printf (\" e %s\", yys);", 31L);
  414.         IO_WriteNl(Tree_f);
  415.         IO_WriteS(Tree_f, (STRING)"  while (yyi -- > 0) (void) putc (' ', stdout);", 47L);
  416.         IO_WriteNl(Tree_f);
  417.         IO_WriteS(Tree_f, (STRING)"  (void) printf (\" = \");", 24L);
  418.         IO_WriteNl(Tree_f);
  419.         IO_WriteS(Tree_f, (STRING)"  (void) fflush (stdout);", 25L);
  420.         IO_WriteNl(Tree_f);
  421.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  422.         IO_WriteNl(Tree_f);
  423.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  424.         IO_WriteNl(Tree_f);
  425.       } else if (Sets_IsElement(ORD('Y'), &Tree_Options)) {
  426.         IO_WriteNl(Tree_f);
  427.         IO_WriteS(Tree_f, (STRING)"static void yyWriteEval", 23L);
  428.         IO_WriteNl(Tree_f);
  429.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  430.         IO_WriteNl(Tree_f);
  431.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  432.         Tree_WI(Tree_itTree);
  433.         IO_WriteS(Tree_f, (STRING)" yyt, char * yys)", 17L);
  434.         IO_WriteNl(Tree_f);
  435.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  436.         IO_WriteNl(Tree_f);
  437.         IO_WriteS(Tree_f, (STRING)" (yyt, yys) ", 12L);
  438.         Tree_WI(Tree_itTree);
  439.         IO_WriteS(Tree_f, (STRING)" yyt; char * yys;", 17L);
  440.         IO_WriteNl(Tree_f);
  441.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  442.         IO_WriteNl(Tree_f);
  443.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  444.         IO_WriteNl(Tree_f);
  445.         IO_WriteS(Tree_f, (STRING)" if (yyTrace) {", 15L);
  446.         IO_WriteNl(Tree_f);
  447.         IO_WriteS(Tree_f, (STRING)"  yyWriteType (yyt);", 20L);
  448.         IO_WriteNl(Tree_f);
  449.         IO_WriteS(Tree_f, (STRING)"  (void) printf (\" e %s\\n\", yys);", 33L);
  450.         IO_WriteNl(Tree_f);
  451.         IO_WriteS(Tree_f, (STRING)"  (void) fflush (stdout);", 25L);
  452.         IO_WriteNl(Tree_f);
  453.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  454.         IO_WriteNl(Tree_f);
  455.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  456.         IO_WriteNl(Tree_f);
  457.       }
  458.       if (Sets_IsElement(ORD('Z'), &Tree_Options)) {
  459.         IO_WriteNl(Tree_f);
  460.         IO_WriteS(Tree_f, (STRING)"static void yyWriteVisit", 24L);
  461.         IO_WriteNl(Tree_f);
  462.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  463.         IO_WriteNl(Tree_f);
  464.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  465.         Tree_WI(Tree_itTree);
  466.         IO_WriteS(Tree_f, (STRING)" yyt, char * yys)", 17L);
  467.         IO_WriteNl(Tree_f);
  468.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  469.         IO_WriteNl(Tree_f);
  470.         IO_WriteS(Tree_f, (STRING)" (yyt, yys) ", 12L);
  471.         Tree_WI(Tree_itTree);
  472.         IO_WriteS(Tree_f, (STRING)" yyt; char * yys;", 17L);
  473.         IO_WriteNl(Tree_f);
  474.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  475.         IO_WriteNl(Tree_f);
  476.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  477.         IO_WriteNl(Tree_f);
  478.         IO_WriteS(Tree_f, (STRING)" if (yyTrace) {", 15L);
  479.         IO_WriteNl(Tree_f);
  480.         IO_WriteS(Tree_f, (STRING)"  yyWriteType (yyt);", 20L);
  481.         IO_WriteNl(Tree_f);
  482.         IO_WriteS(Tree_f, (STRING)"  (void) printf (\" v %s\\n\", yys);", 33L);
  483.         IO_WriteNl(Tree_f);
  484.         IO_WriteS(Tree_f, (STRING)"  (void) fflush (stdout);", 25L);
  485.         IO_WriteNl(Tree_f);
  486.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  487.         IO_WriteNl(Tree_f);
  488.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  489.         IO_WriteNl(Tree_f);
  490.         IO_WriteNl(Tree_f);
  491.         IO_WriteS(Tree_f, (STRING)"static void yyVisitParent", 25L);
  492.         IO_WriteNl(Tree_f);
  493.         IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  494.         IO_WriteNl(Tree_f);
  495.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  496.         Tree_WI(Tree_itTree);
  497.         IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  498.         IO_WriteNl(Tree_f);
  499.         IO_WriteS(Tree_f, (STRING)"# else", 6L);
  500.         IO_WriteNl(Tree_f);
  501.         IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  502.         Tree_WI(Tree_itTree);
  503.         IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  504.         IO_WriteNl(Tree_f);
  505.         IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  506.         IO_WriteNl(Tree_f);
  507.         IO_WriteS(Tree_f, (STRING)"{ yyWriteVisit (yyt, \"parent\"); }", 33L);
  508.         IO_WriteNl(Tree_f);
  509.       }
  510.       return;
  511.     }
  512.   }
  513. }
  514.  
  515. void EvalC_EvalImplC
  516. # ifdef __STDC__
  517. (Tree_tTree t)
  518. # else
  519. (t)
  520. Tree_tTree t;
  521. # endif
  522. {
  523.   struct S_5 yyTempo;
  524.  
  525.   if (t == Tree_NoTree) {
  526.     return;
  527.   }
  528.   if (t->U_1.V_1.Kind == Tree_Ag) {
  529.     {
  530.       register Tree_yAg *W_3 = &t->U_1.V_26.Ag;
  531.  
  532.       EvalC_EvalImplHead(t);
  533.       IO_WriteNl(Tree_f);
  534.       {
  535.         SHORTCARD B_3 = 1, B_4 = Tree_MaxVisit;
  536.  
  537.         if (B_3 <= B_4)
  538.           for (n = B_3;; n += 1) {
  539.             IO_WriteS(Tree_f, (STRING)"static void yyVisit", 19L);
  540.             Tree_WN((LONGINT)n);
  541.             IO_WriteS(Tree_f, (STRING)" ARGS((register ", 16L);
  542.             Tree_WI(Tree_itTree);
  543.             IO_WriteS(Tree_f, (STRING)" yyt));", 7L);
  544.             IO_WriteNl(Tree_f);
  545.             if (n >= B_4) break;
  546.           }
  547.       }
  548.       IO_WriteNl(Tree_f);
  549.       IO_WriteS(Tree_f, (STRING)"void ", 5L);
  550.       Tree_WI(W_3->EvalName);
  551.       IO_WriteNl(Tree_f);
  552.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  553.       IO_WriteNl(Tree_f);
  554.       IO_WriteS(Tree_f, (STRING)" (", 2L);
  555.       Tree_WI(Tree_itTree);
  556.       IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  557.       IO_WriteNl(Tree_f);
  558.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  559.       IO_WriteNl(Tree_f);
  560.       IO_WriteS(Tree_f, (STRING)" (yyt) ", 7L);
  561.       Tree_WI(Tree_itTree);
  562.       IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  563.       IO_WriteNl(Tree_f);
  564.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  565.       IO_WriteNl(Tree_f);
  566.       if (!Sets_IsElement(ORD('9'), &Tree_Options)) {
  567.         IO_WriteS(Tree_f, (STRING)"{ ", 2L);
  568.         if (Tree_MaxVisit > 0) {
  569.           IO_WriteS(Tree_f, (STRING)"yyVisit1 (yyt); ", 16L);
  570.         }
  571.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  572.         IO_WriteNl(Tree_f);
  573.       } else {
  574.         IO_WriteS(Tree_f, (STRING)"{", 1L);
  575.         IO_WriteNl(Tree_f);
  576.         IO_WriteS(Tree_f, (STRING)" char xxHigh;", 13L);
  577.         IO_WriteNl(Tree_f);
  578.         IO_WriteS(Tree_f, (STRING)" xxStack = 1000000000;", 22L);
  579.         IO_WriteNl(Tree_f);
  580.         if (Tree_MaxVisit > 0) {
  581.           IO_WriteS(Tree_f, (STRING)" yyVisit1 (yyt);", 16L);
  582.           IO_WriteNl(Tree_f);
  583.         }
  584.         IO_WriteS(Tree_f, (STRING)" (void) printf (\"Stacksize %d\\n\", (int) & xxHigh - xxStack);", 60L);
  585.         IO_WriteNl(Tree_f);
  586.         IO_WriteS(Tree_f, (STRING)"}", 1L);
  587.         IO_WriteNl(Tree_f);
  588.       }
  589.       IO_WriteNl(Tree_f);
  590.       {
  591.         SHORTCARD B_5 = 1, B_6 = Tree_MaxVisit;
  592.  
  593.         if (B_5 <= B_6)
  594.           for (n = B_5;; n += 1) {
  595.             IO_WriteS(Tree_f, (STRING)"static void yyVisit", 19L);
  596.             Tree_WN((LONGINT)n);
  597.             IO_WriteNl(Tree_f);
  598.             IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  599.             IO_WriteNl(Tree_f);
  600.             IO_WriteS(Tree_f, (STRING)" (register ", 11L);
  601.             Tree_WI(Tree_itTree);
  602.             IO_WriteS(Tree_f, (STRING)" yyt)", 5L);
  603.             IO_WriteNl(Tree_f);
  604.             IO_WriteS(Tree_f, (STRING)"# else", 6L);
  605.             IO_WriteNl(Tree_f);
  606.             IO_WriteS(Tree_f, (STRING)" (yyt) register ", 16L);
  607.             Tree_WI(Tree_itTree);
  608.             IO_WriteS(Tree_f, (STRING)" yyt;", 5L);
  609.             IO_WriteNl(Tree_f);
  610.             IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  611.             IO_WriteNl(Tree_f);
  612.             IO_WriteS(Tree_f, (STRING)"{", 1L);
  613.             IO_WriteNl(Tree_f);
  614.             TreeC2_WriteLine(W_3->EvalCodes->U_1.V_12.Codes.LocalLine);
  615.             Texts_WriteText(Tree_f, W_3->EvalCodes->U_1.V_12.Codes.Local);
  616.             Node = W_3->Modules;
  617.             while (Node->U_1.V_1.Kind == Tree_Module) {
  618.               TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.LocalLine);
  619.               Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Local);
  620.               Node = Node->U_1.V_43.Module.Next;
  621.             }
  622.             if (Sets_IsElement(ORD('9'), &Tree_Options)) {
  623.               IO_WriteS(Tree_f, (STRING)" char xxLow;", 12L);
  624.               IO_WriteNl(Tree_f);
  625.               IO_WriteS(Tree_f, (STRING)" xxStack = Min (xxStack, (int) & xxLow);", 40L);
  626.               IO_WriteNl(Tree_f);
  627.             }
  628.             IO_WriteNl(Tree_f);
  629.             IO_WriteS(Tree_f, (STRING)" switch (yyt->Kind) {", 21L);
  630.             IO_WriteNl(Tree_f);
  631.             if (IN(Tree_cOAG, Tree_GrammarClass)) {
  632.               Tree_ForallClasses(W_3->Classes, (Tree_ProcOfT)EvalC_GenEvaluator);
  633.             }
  634.             IO_WriteS(Tree_f, (STRING)" default: ;", 11L);
  635.             IO_WriteNl(Tree_f);
  636.             if (Sets_IsElement(ORD('Z'), &Tree_Options)) {
  637.               IO_WriteS(Tree_f, (STRING)"  yyVisitParent (yyt);", 22L);
  638.               IO_WriteNl(Tree_f);
  639.             }
  640.             IO_WriteS(Tree_f, (STRING)" }", 2L);
  641.             IO_WriteNl(Tree_f);
  642.             IO_WriteS(Tree_f, (STRING)"}", 1L);
  643.             IO_WriteNl(Tree_f);
  644.             IO_WriteNl(Tree_f);
  645.             if (n >= B_6) break;
  646.           }
  647.       }
  648.       IO_WriteS(Tree_f, (STRING)"void Begin", 10L);
  649.       Tree_WI(W_3->EvalName);
  650.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  651.       IO_WriteNl(Tree_f);
  652.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  653.       IO_WriteNl(Tree_f);
  654.       TreeC2_WriteLine(W_3->EvalCodes->U_1.V_12.Codes.BeginLine);
  655.       Texts_WriteText(Tree_f, W_3->EvalCodes->U_1.V_12.Codes.Begin);
  656.       Node = W_3->Modules;
  657.       while (Node->U_1.V_1.Kind == Tree_Module) {
  658.         TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.BeginLine);
  659.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Begin);
  660.         Node = Node->U_1.V_43.Module.Next;
  661.       }
  662.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  663.       IO_WriteNl(Tree_f);
  664.       IO_WriteNl(Tree_f);
  665.       IO_WriteS(Tree_f, (STRING)"void Close", 10L);
  666.       Tree_WI(W_3->EvalName);
  667.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  668.       IO_WriteNl(Tree_f);
  669.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  670.       IO_WriteNl(Tree_f);
  671.       TreeC2_WriteLine(W_3->EvalCodes->U_1.V_12.Codes.CloseLine);
  672.       Texts_WriteText(Tree_f, W_3->EvalCodes->U_1.V_12.Codes.Close);
  673.       Node = W_3->Modules;
  674.       while (Node->U_1.V_1.Kind == Tree_Module) {
  675.         TreeC2_WriteLine(Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.CloseLine);
  676.         Texts_WriteText(Tree_f, Node->U_1.V_43.Module.EvalCodes->U_1.V_12.Codes.Close);
  677.         Node = Node->U_1.V_43.Module.Next;
  678.       }
  679.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  680.       IO_WriteNl(Tree_f);
  681.       return;
  682.     }
  683.   }
  684. }
  685.  
  686. static void TypeName
  687. # ifdef __STDC__
  688. (Tree_tTree t)
  689. # else
  690. (t)
  691. Tree_tTree t;
  692. # endif
  693. {
  694.   struct S_6 yyTempo;
  695.  
  696.   if (t == Tree_NoTree) {
  697.     return;
  698.   }
  699.   if (t->U_1.V_1.Kind == Tree_Class) {
  700.     for (;;) {
  701.       {
  702.         register Tree_yClass *W_4 = &t->U_1.V_5.Class;
  703.  
  704.         if (!((Tree_NoCodeClass & W_4->Properties) == 0X0L)) {
  705.           goto EXIT_1;
  706.         }
  707.         if (!IN(Tree_Trace, W_4->Properties)) {
  708.           goto EXIT_1;
  709.         }
  710.         IO_WriteS(Tree_f, (STRING)"\"", 1L);
  711.         Tree_WI(W_4->Name);
  712.         IO_WriteS(Tree_f, (STRING)"\",", 2L);
  713.         IO_WriteNl(Tree_f);
  714.         return;
  715.       }
  716.     } EXIT_1:;
  717.   }
  718. }
  719.  
  720. void EvalC_GenEvaluator
  721. # ifdef __STDC__
  722. (Tree_tTree t)
  723. # else
  724. (t)
  725. Tree_tTree t;
  726. # endif
  727. {
  728.   struct S_7 yyTempo;
  729.  
  730.   if (t == Tree_NoTree) {
  731.     return;
  732.   }
  733.   switch (t->U_1.V_1.Kind) {
  734.   case Tree_Class:;
  735.     for (;;) {
  736.       {
  737.         register Tree_yClass *W_5 = &t->U_1.V_5.Class;
  738.  
  739.         if (!((Tree_NoCodeClass & W_5->Properties) == 0X0L)) {
  740.           goto EXIT_2;
  741.         }
  742.         if (W_5->Generated == W_5->InstCount || W_5->Visits < n) {
  743.           return;
  744.         }
  745.         IO_WriteNl(Tree_f);
  746.         IO_WriteS(Tree_f, (STRING)"case k", 6L);
  747.         Tree_WI(W_5->Name);
  748.         IO_WriteS(Tree_f, (STRING)":", 1L);
  749.         IO_WriteNl(Tree_f);
  750.         EvalC_Class = t;
  751.         for (;;) {
  752.           if (W_5->Generated == W_5->InstCount) {
  753.             goto EXIT_3;
  754.           }
  755.           INC(W_5->Generated);
  756.           {
  757.             register Tree_tInstance *W_6 = &W_5->Instance->A[W_5->Instance->A[W_5->Generated - 1].Order - 1];
  758.  
  759.             if (IN(Tree_Left, W_6->Properties) && W_6->Attribute->U_1.V_9.Child.Partition > n) {
  760.               DEC(W_5->Generated);
  761.               goto EXIT_3;
  762.             }
  763.             if (SET_IS_SUBSET1(SET_ELEM(Tree_Inherited) | SET_ELEM(Tree_Right) | SET_ELEM(Tree_First), W_6->Properties) && !IN(Tree_Virtual, W_6->Properties)) {
  764.               if (Sets_IsElement(ORD('X'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  765.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  766.                 Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  767.                 IO_WriteS(Tree_f, (STRING)":", 1L);
  768.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  769.                 IO_WriteS(Tree_f, (STRING)"\");", 3L);
  770.                 IO_WriteNl(Tree_f);
  771.                 if (W_6->Action != ADR(W_6->Action)) {
  772.                   EvalC_GenEvaluator(W_6->Action);
  773.                 }
  774.                 IO_WriteNl(Tree_f);
  775.                 if (W_6->Attribute->U_1.V_1.Kind == Tree_Child || W_6->Attribute->U_1.V_10.Attribute.Type == Tree_itTree) {
  776.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  777.                   Tree_WI(Tree_itTree);
  778.                   IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  779.                   Tree_WI(W_5->Name);
  780.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  781.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  782.                   IO_WriteS(Tree_f, (STRING)"->", 2L);
  783.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Type);
  784.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  785.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  786.                   IO_WriteS(Tree_f, (STRING)")", 1L);
  787.                   IO_WriteNl(Tree_f);
  788.                 } else {
  789.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  790.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Type);
  791.                   IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  792.                   Tree_WI(W_5->Name);
  793.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  794.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  795.                   IO_WriteS(Tree_f, (STRING)"->", 2L);
  796.                   Tree_WI(W_6->Selector->U_1.V_9.Child.Type);
  797.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  798.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  799.                   IO_WriteS(Tree_f, (STRING)") yyWriteNl ();", 15L);
  800.                   IO_WriteNl(Tree_f);
  801.                 }
  802.               } else if (Sets_IsElement(ORD('Y'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  803.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  804.                 Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  805.                 IO_WriteS(Tree_f, (STRING)":", 1L);
  806.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  807.                 IO_WriteS(Tree_f, (STRING)"\");", 3L);
  808.                 IO_WriteNl(Tree_f);
  809.                 if (W_6->Action != ADR(W_6->Action)) {
  810.                   EvalC_GenEvaluator(W_6->Action);
  811.                 }
  812.               } else {
  813.                 if (W_6->Action != ADR(W_6->Action)) {
  814.                   EvalC_GenEvaluator(W_6->Action);
  815.                 }
  816.               }
  817.             }
  818.             if (SET_IS_SUBSET1(SET_ELEM(Tree_Synthesized) | SET_ELEM(Tree_Left) | SET_ELEM(Tree_First), W_6->Properties) && ((SET_ELEM(Tree_Dummy) | SET_ELEM(Tree_Virtual)) & W_6->Properties) == 0X0L) {
  819.               if (Sets_IsElement(ORD('X'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  820.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  821.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  822.                 IO_WriteS(Tree_f, (STRING)"\");", 3L);
  823.                 IO_WriteNl(Tree_f);
  824.                 if (W_6->Action != ADR(W_6->Action)) {
  825.                   EvalC_GenEvaluator(W_6->Action);
  826.                 }
  827.                 IO_WriteNl(Tree_f);
  828.                 if (IN(Tree_Test, W_6->Properties)) {
  829.                   IO_WriteS(Tree_f, (STRING)"writebool (yyb) yyWriteNl ();", 29L);
  830.                   IO_WriteNl(Tree_f);
  831.                 } else if (W_6->Attribute->U_1.V_1.Kind == Tree_Child || W_6->Attribute->U_1.V_10.Attribute.Type == Tree_itTree) {
  832.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  833.                   Tree_WI(Tree_itTree);
  834.                   IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  835.                   Tree_WI(W_5->Name);
  836.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  837.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  838.                   IO_WriteS(Tree_f, (STRING)")", 1L);
  839.                 } else {
  840.                   IO_WriteS(Tree_f, (STRING)"write", 5L);
  841.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Type);
  842.                   IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  843.                   Tree_WI(W_5->Name);
  844.                   IO_WriteS(Tree_f, (STRING)".", 1L);
  845.                   Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  846.                   IO_WriteS(Tree_f, (STRING)") yyWriteNl ();", 15L);
  847.                   IO_WriteNl(Tree_f);
  848.                 }
  849.               } else if (Sets_IsElement(ORD('Y'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  850.                 IO_WriteS(Tree_f, (STRING)"yyWriteEval (yyt, \"", 19L);
  851.                 Tree_WI(W_6->Attribute->U_1.V_9.Child.Name);
  852.                 IO_WriteS(Tree_f, (STRING)"\");", 3L);
  853.                 IO_WriteNl(Tree_f);
  854.                 if (W_6->Action != ADR(W_6->Action)) {
  855.                   EvalC_GenEvaluator(W_6->Action);
  856.                 }
  857.               } else {
  858.                 if (W_6->Action != ADR(W_6->Action)) {
  859.                   EvalC_GenEvaluator(W_6->Action);
  860.                 }
  861.               }
  862.             }
  863.             if (SET_IS_SUBSET1(SET_ELEM(Tree_Synthesized) | SET_ELEM(Tree_Right) | SET_ELEM(Tree_First), W_6->Properties) && W_6->Attribute->U_1.V_9.Child.Partition <= W_6->Selector->U_1.V_9.Child.Class->U_1.V_5.Class.Visits) {
  864.               if (Sets_IsElement(ORD('Z'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  865.                 IO_WriteS(Tree_f, (STRING)"yyWriteVisit (yyt, \"", 20L);
  866.                 Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  867.                 IO_WriteS(Tree_f, (STRING)" ", 1L);
  868.                 Tree_WN((LONGINT)W_6->Attribute->U_1.V_9.Child.Partition);
  869.                 IO_WriteS(Tree_f, (STRING)"\");", 3L);
  870.                 IO_WriteNl(Tree_f);
  871.               }
  872.               IO_WriteS(Tree_f, (STRING)"yyVisit", 7L);
  873.               Tree_WN((LONGINT)W_6->Attribute->U_1.V_9.Child.Partition);
  874.               IO_WriteS(Tree_f, (STRING)" (yyt->", 7L);
  875.               Tree_WI(W_5->Name);
  876.               IO_WriteS(Tree_f, (STRING)".", 1L);
  877.               Tree_WI(W_6->Selector->U_1.V_9.Child.Name);
  878.               IO_WriteS(Tree_f, (STRING)");", 2L);
  879.               IO_WriteNl(Tree_f);
  880.             }
  881.           }
  882.         } EXIT_3:;
  883.         if (Sets_IsElement(ORD('Z'), &Tree_Options) && IN(Tree_Trace, t->U_1.V_5.Class.Properties)) {
  884.           IO_WriteS(Tree_f, (STRING)"yyVisitParent (yyt);", 20L);
  885.           IO_WriteNl(Tree_f);
  886.         }
  887.         IO_WriteS(Tree_f, (STRING)"break;", 6L);
  888.         IO_WriteNl(Tree_f);
  889.         return;
  890.       }
  891.     } EXIT_2:;
  892.     break;
  893.   case Tree_Assign:;
  894.     {
  895.       register Tree_yAssign *W_7 = &t->U_1.V_36.Assign;
  896.  
  897.       TreeC2_WriteLine(W_7->Pos);
  898.       EvalC_GenEvaluator(W_7->Results);
  899.       IO_WriteS(Tree_f, (STRING)"=", 1L);
  900.       EvalC_GenEvaluator(W_7->Arguments);
  901.       IO_WriteS(Tree_f, (STRING)";", 1L);
  902.       IO_WriteNl(Tree_f);
  903.       return;
  904.     }
  905.     break;
  906.   case Tree_Copy:;
  907.     {
  908.       register Tree_yCopy *W_8 = &t->U_1.V_37.Copy;
  909.  
  910.       TreeC2_WriteLine(W_8->Pos);
  911.       EvalC_GenEvaluator(W_8->Results);
  912.       IO_WriteS(Tree_f, (STRING)"=", 1L);
  913.       EvalC_GenEvaluator(W_8->Arguments);
  914.       IO_WriteS(Tree_f, (STRING)";", 1L);
  915.       IO_WriteNl(Tree_f);
  916.       return;
  917.     }
  918.     break;
  919.   case Tree_TargetCode:;
  920.     {
  921.       register Tree_yTargetCode *W_9 = &t->U_1.V_38.TargetCode;
  922.  
  923.       TreeC2_WriteLine(W_9->Pos);
  924.       EvalC_GenEvaluator(W_9->Code);
  925.       IO_WriteNl(Tree_f);
  926.       return;
  927.     }
  928.     break;
  929.   case Tree_Check:;
  930.     {
  931.       register Tree_yCheck *W_10 = &t->U_1.V_40.Check;
  932.  
  933.       TreeC2_WriteLine(W_10->Pos);
  934.       if (W_10->Condition != Tree_NoTree) {
  935.         IO_WriteS(Tree_f, (STRING)"if (! (", 7L);
  936.         if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  937.           IO_WriteS(Tree_f, (STRING)"yyb = ", 6L);
  938.         }
  939.         EvalC_GenEvaluator(W_10->Condition);
  940.         IO_WriteS(Tree_f, (STRING)")) {", 4L);
  941.         EvalC_GenEvaluator(W_10->Statement);
  942.         IO_WriteS(Tree_f, (STRING)"; }", 3L);
  943.         IO_WriteNl(Tree_f);
  944.         if (W_10->Actions->U_1.V_1.Kind == Tree_Check) {
  945.           IO_WriteS(Tree_f, (STRING)"else", 4L);
  946.           IO_WriteNl(Tree_f);
  947.           EvalC_GenEvaluator(W_10->Actions);
  948.         }
  949.       } else {
  950.         if (Sets_IsElement(ORD('X'), &Tree_Options)) {
  951.           IO_WriteS(Tree_f, (STRING)"yyb = false; ", 13L);
  952.         }
  953.         EvalC_GenEvaluator(W_10->Statement);
  954.         IO_WriteS(Tree_f, (STRING)";", 1L);
  955.         IO_WriteNl(Tree_f);
  956.         EvalC_GenEvaluator(W_10->Actions);
  957.       }
  958.       return;
  959.     }
  960.     break;
  961.   case Tree_Designator:;
  962.     {
  963.       register Tree_yDesignator *W_11 = &t->U_1.V_15.Designator;
  964.  
  965.       Attr = Tree_IdentifyAttribute(EvalC_Class, W_11->Selector);
  966.       if (Attr != Tree_NoTree) {
  967.         ChildsClass = Attr->U_1.V_9.Child.Class;
  968.         Attr = Tree_IdentifyAttribute(ChildsClass, W_11->Attribute);
  969.         if (!IN(Tree_Virtual, Attr->U_1.V_10.Attribute.Properties)) {
  970.           IO_WriteS(Tree_f, (STRING)"yyt->", 5L);
  971.           Tree_WI(EvalC_Class->U_1.V_5.Class.Name);
  972.           IO_WriteS(Tree_f, (STRING)".", 1L);
  973.           Tree_WI(W_11->Selector);
  974.           IO_WriteS(Tree_f, (STRING)"->", 2L);
  975.           Tree_WI(ChildsClass->U_1.V_5.Class.Name);
  976.           IO_WriteS(Tree_f, (STRING)".", 1L);
  977.           Tree_WI(W_11->Attribute);
  978.         }
  979.       } else {
  980.         Tree_WI(W_11->Selector);
  981.         IO_WriteS(Tree_f, (STRING)":", 1L);
  982.         Tree_WI(W_11->Attribute);
  983.       }
  984.       EvalC_GenEvaluator(W_11->Next);
  985.       return;
  986.     }
  987.     break;
  988.   case Tree_Ident:;
  989.     {
  990.       register Tree_yIdent *W_12 = &t->U_1.V_16.Ident;
  991.  
  992.       Attr = Tree_IdentifyAttribute(EvalC_Class, W_12->Attribute);
  993.       if (Attr != Tree_NoTree) {
  994.         if (!IN(Tree_Virtual, Attr->U_1.V_10.Attribute.Properties)) {
  995.           IO_WriteS(Tree_f, (STRING)"yyt->", 5L);
  996.           Tree_WI(EvalC_Class->U_1.V_5.Class.Name);
  997.           IO_WriteS(Tree_f, (STRING)".", 1L);
  998.           Tree_WI(W_12->Attribute);
  999.         }
  1000.       } else {
  1001.         Tree_WI(W_12->Attribute);
  1002.       }
  1003.       EvalC_GenEvaluator(W_12->Next);
  1004.       return;
  1005.     }
  1006.     break;
  1007.   case Tree_Remote:;
  1008.     {
  1009.       register struct S_8 *W_13 = &yyTempo.U_1.V_1.yyR8;
  1010.  
  1011.       {
  1012.         register Tree_yRemote *W_14 = &t->U_1.V_17.Remote;
  1013.  
  1014.         W_13->TheClass = Tree_IdentifyClass(Tree_TreeRoot->U_1.V_26.Ag.Classes, W_14->Type);
  1015.         if (W_13->TheClass != Tree_NoTree) {
  1016.           Attr = Tree_IdentifyAttribute(W_13->TheClass, W_14->Attribute);
  1017.           if (Attr != Tree_NoTree) {
  1018.             {
  1019.               register Tree_yAttribute *W_15 = &Attr->U_1.V_10.Attribute;
  1020.  
  1021.               W_13->k = EvalC3_ToBit0(W_13->TheClass, (LONGINT)W_15->AttrIndex);
  1022.               if (IN(Tree_Synthesized, W_15->Properties)) {
  1023.                 IO_WriteS(Tree_f, (STRING)"REMOTE_SYN (yyIsComp", 20L);
  1024.                 Tree_WN(W_13->k / TreeC1_BSS);
  1025.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1026.                 Tree_WN(W_13->k % TreeC1_BSS);
  1027.                 IO_WriteS(Tree_f, (STRING)", yyS", 5L);
  1028.                 Tree_WN(W_13->k);
  1029.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1030.                 EvalC_GenEvaluator(W_14->Designators);
  1031.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1032.                 Tree_WI(t->U_1.V_17.Remote.Type);
  1033.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1034.                 Tree_WI(W_14->Attribute);
  1035.                 IO_WriteS(Tree_f, (STRING)")", 1L);
  1036.               } else if (IN(Tree_Inherited, W_15->Properties)) {
  1037.                 IO_WriteS(Tree_f, (STRING)"REMOTE_INH (yyIsComp", 20L);
  1038.                 Tree_WN(W_13->k / TreeC1_BSS);
  1039.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1040.                 Tree_WN(W_13->k % TreeC1_BSS);
  1041.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1042.                 Tree_WN(W_13->k);
  1043.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1044.                 EvalC_GenEvaluator(W_14->Designators);
  1045.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1046.                 Tree_WI(t->U_1.V_17.Remote.Type);
  1047.                 IO_WriteS(Tree_f, (STRING)", ", 2L);
  1048.                 Tree_WI(W_14->Attribute);
  1049.                 IO_WriteS(Tree_f, (STRING)")", 1L);
  1050.               } else {
  1051.                 EvalC_GenEvaluator(W_14->Designators);
  1052.                 IO_WriteS(Tree_f, (STRING)"->", 2L);
  1053.                 Tree_WI(t->U_1.V_17.Remote.Type);
  1054.                 IO_WriteS(Tree_f, (STRING)".", 1L);
  1055.                 Tree_WI(W_14->Attribute);
  1056.               }
  1057.             }
  1058.           }
  1059.         }
  1060.         EvalC_GenEvaluator(W_14->Next);
  1061.         return;
  1062.       }
  1063.     }
  1064.     break;
  1065.   case Tree_Any:;
  1066.     {
  1067.       register Tree_yAny *W_16 = &t->U_1.V_18.Any;
  1068.  
  1069.       StringMem_WriteString(Tree_f, W_16->Code);
  1070.       EvalC_GenEvaluator(W_16->Next);
  1071.       return;
  1072.     }
  1073.     break;
  1074.   case Tree_Anys:;
  1075.     {
  1076.       register Tree_yAnys *W_17 = &t->U_1.V_19.Anys;
  1077.  
  1078.       EvalC_GenEvaluator(W_17->Layouts);
  1079.       EvalC_GenEvaluator(W_17->Next);
  1080.       return;
  1081.     }
  1082.     break;
  1083.   case Tree_LayoutAny:;
  1084.     {
  1085.       register Tree_yLayoutAny *W_18 = &t->U_1.V_22.LayoutAny;
  1086.  
  1087.       StringMem_WriteString(Tree_f, W_18->Code);
  1088.       EvalC_GenEvaluator(W_18->Next);
  1089.       return;
  1090.     }
  1091.     break;
  1092.   default :
  1093.     break;
  1094.   }
  1095. }
  1096.  
  1097. void EvalC_BeginEvalC
  1098. # ifdef __STDC__
  1099. ()
  1100. # else
  1101. ()
  1102. # endif
  1103. {
  1104. }
  1105.  
  1106. void EvalC_CloseEvalC
  1107. # ifdef __STDC__
  1108. ()
  1109. # else
  1110. ()
  1111. # endif
  1112. {
  1113. }
  1114.  
  1115. static void yyExit
  1116. # ifdef __STDC__
  1117. ()
  1118. # else
  1119. ()
  1120. # endif
  1121. {
  1122.   IO_CloseIO();
  1123.   Exit(1L);
  1124. }
  1125.  
  1126. void BEGIN_EvalC()
  1127. {
  1128.   static BOOLEAN has_been_called = FALSE;
  1129.  
  1130.   if (!has_been_called) {
  1131.     has_been_called = TRUE;
  1132.  
  1133.     BEGIN_IO();
  1134.     BEGIN_Tree();
  1135.     BEGIN_System();
  1136.     BEGIN_IO();
  1137.     BEGIN_Tree();
  1138.     BEGIN_IO();
  1139.     BEGIN_StringMem();
  1140.     BEGIN_Idents();
  1141.     BEGIN_Texts();
  1142.     BEGIN_Sets();
  1143.     BEGIN_TreeC1();
  1144.     BEGIN_TreeC2();
  1145.     BEGIN_EvalC3();
  1146.     BEGIN_Tree();
  1147.  
  1148.     EvalC_yyf = IO_StdOutput;
  1149.     EvalC_Exit = yyExit;
  1150.     EvalC_BeginEvalC();
  1151.   }
  1152. }
  1153.